//! 缓存插件演示程序
//! 
//! 展示缓存插件系统的核心功能

use std::collections::HashMap;
use anyhow::Result;

// 缓存插件相关导入
use data_gateway_cache_plugin::{
    CacheManager, CacheConfig, CacheType, MemoryCacheConfig,
    QueryCache, QueryInfo, QueryType, QueryResultMetadata, QueryTypeDetector,
    MemoryCacheBuilder
};

#[tokio::main]
async fn main() -> Result<()> {
    println!("🚀 数据网关缓存插件演示程序");
    println!("========================================");

    // 1. 演示内存缓存功能
    println!("\n💾 1. 内存缓存功能演示");
    demo_memory_cache().await?;

    // 2. 演示查询缓存功能
    println!("\n🔍 2. 查询缓存功能演示");
    demo_query_cache().await?;

    // 3. 演示缓存管理器功能
    println!("\n🎛️ 3. 缓存管理器功能演示");
    demo_cache_manager().await?;

    println!("\n✅ 缓存插件演示完成！");
    println!("========================================");

    Ok(())
}

/// 演示内存缓存功能
async fn demo_memory_cache() -> Result<()> {
    println!("  创建内存缓存实例...");
    
    let cache = MemoryCacheBuilder::new()
        .max_capacity(1000)
        .initial_capacity(100)
        .time_to_live(3600) // 1小时
        .time_to_idle(1800) // 30分钟
        .build();

    println!("    ✅ 内存缓存创建成功");
    println!("    ✅ 最大容量: 1000");
    println!("    ✅ 初始容量: 100");
    println!("    ✅ TTL: 3600秒");

    // 测试基本缓存操作
    println!("  🔄 测试基本缓存操作...");
    
    let key = "user:123".to_string();
    let value = serde_json::json!({
        "id": 123,
        "name": "张三",
        "email": "zhangsan@example.com",
        "department": "技术部",
        "role": "高级工程师"
    }).to_string().into_bytes();

    // 设置缓存
    cache.set(&key, value.clone(), Some(3600)).await?;
    println!("    ✅ 缓存设置成功，键: {}", key);

    // 获取缓存
    let result = cache.get(&key).await?;
    if result.is_hit() {
        let cached_value = result.value().unwrap();
        println!("    ✅ 缓存命中，值长度: {} 字节", cached_value.len());
        
        // 解析JSON验证数据完整性
        if let Ok(json_str) = String::from_utf8(cached_value) {
            if let Ok(user_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
                println!("    ✅ 数据验证成功，用户: {}", user_data["name"]);
            }
        }
    }

    // 检查存在性
    let exists = cache.exists(&key).await?;
    println!("    ✅ 缓存存在检查: {}", exists);

    // 获取TTL
    let ttl = cache.ttl(&key).await?;
    if let Some(remaining) = ttl {
        println!("    ✅ 剩余TTL: {} 秒", remaining);
    }

    // 测试批量操作
    println!("  📦 测试批量缓存操作...");
    for i in 1..=5 {
        let batch_key = format!("batch_item:{}", i);
        let batch_value = format!("批量数据项 {}", i).into_bytes();
        cache.set(&batch_key, batch_value, Some(1800)).await?;
    }
    println!("    ✅ 批量设置5个缓存项完成");

    // 健康检查
    let healthy = cache.health_check().await?;
    println!("    ✅ 健康检查: {}", healthy);

    // 获取统计信息
    let stats = cache.stats().await?;
    println!("    ✅ 缓存统计:");
    println!("      - 条目数: {}", stats.entries);
    println!("      - 命中数: {}", stats.hits);
    println!("      - 未命中数: {}", stats.misses);
    println!("      - 命中率: {:.2}%", stats.hit_rate() * 100.0);

    Ok(())
}

/// 演示查询缓存功能
async fn demo_query_cache() -> Result<()> {
    println!("  创建查询缓存系统...");

    // 创建底层缓存
    let memory_cache = MemoryCacheBuilder::new()
        .max_capacity(500)
        .build();
    let cache_provider = std::sync::Arc::new(memory_cache);

    // 创建查询缓存配置
    let mut query_config = data_gateway_cache_plugin::QueryCacheConfig::default();
    query_config.enabled = true;
    query_config.default_ttl = 1800; // 30分钟
    query_config.max_result_size = 5 * 1024 * 1024; // 5MB
    query_config.cache_empty_results = false;

    // 创建查询缓存
    let query_cache = QueryCache::new(cache_provider, query_config);
    println!("    ✅ 查询缓存创建成功");

    // 测试查询类型检测
    println!("  🔍 测试查询类型检测...");
    let test_queries = vec![
        ("SELECT * FROM users WHERE age > 18", QueryType::Select),
        ("INSERT INTO users (name, email) VALUES ('李四', 'lisi@example.com')", QueryType::Insert),
        ("UPDATE users SET email = 'new@example.com' WHERE id = 1", QueryType::Update),
        ("DELETE FROM users WHERE id = 1", QueryType::Delete),
        ("CREATE TABLE products (id INT, name VARCHAR(100))", QueryType::DDL),
        ("EXPLAIN SELECT * FROM orders", QueryType::Other),
    ];

    for (sql, expected_type) in test_queries {
        let detected_type = QueryTypeDetector::detect_query_type(sql);
        let matches = std::mem::discriminant(&detected_type) == std::mem::discriminant(&expected_type);
        println!("    {} SQL: {} -> {:?}", 
            if matches { "✅" } else { "❌" }, 
            &sql[..50.min(sql.len())], detected_type);
    }

    // 测试查询缓存
    println!("  💾 测试查询结果缓存...");
    
    let mut parameters = HashMap::new();
    parameters.insert("min_age".to_string(), serde_json::Value::Number(serde_json::Number::from(18)));
    parameters.insert("department".to_string(), serde_json::Value::String("技术部".to_string()));
    
    let query_info = QueryInfo {
        sql: "SELECT id, name, email FROM users WHERE age >= ? AND department = ?".to_string(),
        parameters,
        datasource: "user_database".to_string(),
        query_type: QueryType::Select,
    };

    // 检查查询是否可缓存
    let cacheable = query_cache.is_cacheable(&query_info);
    println!("    ✅ 查询可缓存性: {}", cacheable);

    if cacheable {
        // 模拟查询结果
        let result_data = serde_json::json!([
            {"id": 1, "name": "张三", "email": "zhangsan@example.com", "age": 25, "department": "技术部"},
            {"id": 2, "name": "李四", "email": "lisi@example.com", "age": 30, "department": "技术部"},
            {"id": 3, "name": "王五", "email": "wangwu@example.com", "age": 22, "department": "技术部"},
            {"id": 4, "name": "赵六", "email": "zhaoliu@example.com", "age": 28, "department": "技术部"}
        ]).to_string().into_bytes();

        let metadata = QueryResultMetadata {
            row_count: 4,
            column_count: 4,
            execution_time_ms: 45.2,
            result_size_bytes: result_data.len(),
            cached_at: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs(),
        };

        // 缓存查询结果
        query_cache.cache_query_result(
            query_info.clone(),
            result_data.clone(),
            metadata
        ).await?;
        println!("    ✅ 查询结果已缓存，大小: {} 字节", result_data.len());

        // 获取缓存的查询结果
        let cached_result = query_cache.get_cached_result(&query_info).await?;
        if let Some(result) = cached_result {
            println!("    ✅ 缓存命中:");
            println!("      - 行数: {}", result.metadata.row_count);
            println!("      - 列数: {}", result.metadata.column_count);
            println!("      - 执行时间: {:.2}ms", result.metadata.execution_time_ms);
            println!("      - 结果大小: {} 字节", result.metadata.result_size_bytes);
            println!("      - 数据源: {}", result.query_info.datasource);
        }

        // 生成缓存键
        let cache_key = query_cache.generate_cache_key(&query_info);
        println!("    ✅ 缓存键: {}...", &cache_key[..32]);

        // 获取查询TTL
        let ttl = query_cache.get_query_ttl(&query_info);
        println!("    ✅ 查询TTL: {} 秒", ttl);

        // 测试缓存失效
        let invalidated = query_cache.invalidate_query(&query_info).await?;
        println!("    ✅ 缓存失效: {}", invalidated);

        // 验证失效后无法命中
        let after_invalidation = query_cache.get_cached_result(&query_info).await?;
        println!("    ✅ 失效后查询结果: {}", if after_invalidation.is_none() { "未命中" } else { "仍命中" });
    }

    // 获取查询缓存统计
    let stats = query_cache.get_cache_stats().await?;
    println!("    ✅ 查询缓存统计:");
    println!("      - 启用状态: {}", stats["enabled"]);
    println!("      - 默认TTL: {} 秒", stats["default_ttl"]);
    println!("      - 最大结果大小: {} 字节", stats["max_result_size"]);

    Ok(())
}

/// 演示缓存管理器功能
async fn demo_cache_manager() -> Result<()> {
    println!("  创建缓存管理器...");

    // 创建缓存配置
    let config = CacheConfig {
        cache_type: CacheType::Memory,
        default_ttl: 3600,
        max_size: Some(1000),
        redis_config: None,
        memory_config: Some(MemoryCacheConfig {
            max_capacity: 1000,
            initial_capacity: Some(100),
            time_to_live: Some(3600),
            time_to_idle: Some(1800),
        }),
    };

    // 创建缓存管理器
    let manager = CacheManager::new(config).await?;
    println!("    ✅ 缓存管理器创建成功");

    // 测试基本操作
    println!("  🔄 测试缓存管理器操作...");
    
    let key = "product:456".to_string();
    let value = serde_json::json!({
        "id": 456,
        "name": "笔记本电脑",
        "brand": "ThinkPad",
        "price": 5999.99,
        "category": "电子产品",
        "specs": {
            "cpu": "Intel i7",
            "memory": "16GB",
            "storage": "512GB SSD"
        }
    }).to_string().into_bytes();

    // 设置缓存
    manager.set(&key, value.clone(), Some(3600)).await?;
    println!("    ✅ 通过管理器设置缓存成功");

    // 获取缓存
    let result = manager.get(&key).await?;
    if result.is_hit() {
        println!("    ✅ 通过管理器获取缓存成功，大小: {} 字节", result.value().unwrap().len());
    }

    // 测试查询缓存功能
    println!("  📋 测试查询缓存集成...");
    
    let query_info = QueryInfo {
        sql: "SELECT * FROM products WHERE category = 'electronics' AND price < 10000".to_string(),
        parameters: HashMap::new(),
        datasource: "product_database".to_string(),
        query_type: QueryType::Select,
    };

    let query_result = serde_json::json!([
        {"id": 456, "name": "笔记本电脑", "price": 5999.99, "category": "电子产品"},
        {"id": 457, "name": "台式机", "price": 4999.99, "category": "电子产品"},
        {"id": 458, "name": "显示器", "price": 1999.99, "category": "电子产品"}
    ]).to_string().into_bytes();

    let metadata = QueryResultMetadata {
        row_count: 3,
        column_count: 4,
        execution_time_ms: 23.5,
        result_size_bytes: query_result.len(),
        cached_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    };

    // 缓存查询结果
    manager.cache_query_result(query_info.clone(), query_result, metadata).await?;
    println!("    ✅ 查询结果通过管理器缓存成功");

    // 获取缓存的查询结果
    let cached_query = manager.get_cached_query_result(&query_info).await?;
    if let Some(result) = cached_query {
        println!("    ✅ 查询缓存命中，行数: {}", result.metadata.row_count);
    }

    // 获取管理器统计信息
    let stats = manager.get_stats().await?;
    println!("    ✅ 缓存管理器统计:");
    println!("      - 总请求数: {}", stats["manager"]["total_requests"]);
    println!("      - 主缓存命中数: {}", stats["manager"]["primary_hits"]);
    println!("      - 查询缓存命中数: {}", stats["manager"]["query_cache_hits"]);
    println!("      - 整体命中率: {:.2}%", stats["manager"]["hit_rate"].as_f64().unwrap_or(0.0) * 100.0);

    // 健康检查
    let health = manager.health_check().await?;
    println!("    ✅ 健康检查结果:");
    println!("      - 整体健康: {}", health["healthy"]);
    println!("      - 主缓存健康: {}", health["primary_cache"]);

    // 测试删除操作
    let deleted = manager.delete(&key).await?;
    println!("    ✅ 缓存删除: {}", deleted);

    Ok(())
}
